/**
 * 设备和编组操作工具
 * 提供统一的设备和编组操作函数，减少页面代码冗余
 */

const DataManager = require('./data-manager')
const { logger } = require('./logger')
const { createBatchUpdater } = require('./utils')

/**
 * 设备操作工具
 */
const DeviceOperations = {
  /**
   * 添加设备并更新页面数据
   * @param {Object} device - 设备对象
   * @param {Object} pageContext - 页面实例 (this)
   * @returns {boolean} 是否添加成功
   */
  addDevice(device, pageContext) {
    if (!device || !device.id) {
      logger.error('添加设备失败: 无效的设备对象', device)
      return false
    }

    // 添加设备到存储
    const result = DataManager.addDevice(device)
    if (!result) return false

    // 更新页面数据
    if (pageContext && pageContext.data && Array.isArray(pageContext.data.devices)) {
      const devices = [...pageContext.data.devices, device]
      pageContext.setData({ devices })
    }

    return true
  },

  /**
   * 更新设备并更新页面数据
   * @param {Object} device - 设备对象
   * @param {Object} pageContext - 页面实例 (this)
   * @returns {boolean} 是否更新成功
   */
  updateDevice(device, pageContext) {
    if (!device || !device.id) {
      logger.error('更新设备失败: 无效的设备对象', device)
      return false
    }

    // 更新设备到存储
    const result = DataManager.updateDevice(device)
    if (!result) return false

    // 更新页面数据
    if (pageContext && pageContext.data && Array.isArray(pageContext.data.devices)) {
      const devices = [...pageContext.data.devices]
      const index = devices.findIndex(d => d.id === device.id)
      if (index >= 0) {
        devices[index] = { ...devices[index], ...device }
        pageContext.setData({ devices })
      }
    }

    return true
  },

  /**
   * 删除设备并更新页面数据
   * @param {string} deviceId - 设备ID
   * @param {Object} pageContext - 页面实例 (this)
   * @returns {boolean} 是否删除成功
   */
  removeDevice(deviceId, pageContext) {
    if (!deviceId) {
      logger.error('删除设备失败: 无效的设备ID')
      return false
    }

    // 删除设备从存储
    const result = DataManager.removeDevice(deviceId)
    if (!result) return false

    // 更新页面数据
    if (pageContext && pageContext.data && Array.isArray(pageContext.data.devices)) {
      const devices = pageContext.data.devices.filter(d => d.id !== deviceId)
      pageContext.setData({ devices })
    }

    return true
  },

  /**
   * 更新设备电源状态
   * @param {string} deviceId - 设备ID
   * @param {boolean} power - 电源状态
   * @param {Object} pageContext - 页面实例 (this)
   * @returns {boolean} 是否更新成功
   */
  updateDevicePower(deviceId, power, pageContext) {
    if (!deviceId) {
      logger.error('更新设备电源状态失败: 无效的设备ID')
      return false
    }

    // 获取设备
    const device = DataManager.getDeviceById(deviceId)
    if (!device) {
      logger.warn(`更新设备电源状态失败: 设备不存在，ID: ${deviceId}`)
      return false
    }

    // 更新设备电源状态
    device.power = power
    const result = DataManager.updateDevice(device)
    if (!result) return false

    // 更新页面数据
    if (pageContext && pageContext.data && Array.isArray(pageContext.data.devices)) {
      const devices = [...pageContext.data.devices]
      const index = devices.findIndex(d => d.id === deviceId)
      if (index >= 0) {
        // 使用路径更新，减少渲染消耗
        pageContext.setData({
          [`devices[${index}].power`]: power,
        })
      }
    }

    return true
  },

  /**
   * 批量更新多个设备
   * @param {Array} devices - 设备对象数组
   * @param {Object} pageContext - 页面实例 (this)
   * @returns {boolean} 是否更新成功
   */
  batchUpdateDevices(devices, pageContext) {
    if (!Array.isArray(devices) || devices.length === 0) {
      logger.error('批量更新设备失败: 无效的设备数组')
      return false
    }

    // 创建批量更新器
    const batchUpdater = pageContext._batchUpdater || createBatchUpdater(pageContext)
    if (!pageContext._batchUpdater) {
      pageContext._batchUpdater = batchUpdater
    }

    // 更新到存储
    let allSuccess = true
    for (const device of devices) {
      if (!device || !device.id) continue
      const result = DataManager.updateDevice(device)
      if (!result) allSuccess = false
    }

    // 更新页面数据
    if (pageContext && pageContext.data && Array.isArray(pageContext.data.devices)) {
      const updatedDevices = [...pageContext.data.devices]
      
      // 更新每个设备
      devices.forEach(device => {
        const index = updatedDevices.findIndex(d => d.id === device.id)
        if (index >= 0) {
          updatedDevices[index] = { ...updatedDevices[index], ...device }
        }
      })
      
      // 使用批量更新
      batchUpdater.update({ devices: updatedDevices })
    }

    return allSuccess
  }
}

/**
 * 编组操作工具
 */
const GroupOperations = {
  /**
   * 添加编组并更新页面数据
   * @param {Object} group - 编组对象
   * @param {Object} pageContext - 页面实例 (this)
   * @returns {boolean} 是否添加成功
   */
  addGroup(group, pageContext) {
    if (!group || !group.id) {
      logger.error('添加编组失败: 无效的编组对象', group)
      return false
    }

    // 添加编组到存储
    const result = DataManager.addGroup(group)
    if (!result) return false

    // 更新页面数据
    if (pageContext && pageContext.data && Array.isArray(pageContext.data.groups)) {
      const groups = [...pageContext.data.groups, group]
      pageContext.setData({ groups })
    }

    return true
  },

  /**
   * 更新编组并更新页面数据
   * @param {Object} group - 编组对象
   * @param {Object} pageContext - 页面实例 (this)
   * @returns {boolean} 是否更新成功
   */
  updateGroup(group, pageContext) {
    if (!group || !group.id) {
      logger.error('更新编组失败: 无效的编组对象', group)
      return false
    }

    // 更新编组到存储
    const result = DataManager.updateGroup(group)
    if (!result) return false

    // 更新页面数据
    if (pageContext && pageContext.data && Array.isArray(pageContext.data.groups)) {
      const groups = [...pageContext.data.groups]
      const index = groups.findIndex(g => g.id === group.id)
      if (index >= 0) {
        groups[index] = { ...groups[index], ...group }
        pageContext.setData({ groups })
      }
    }

    return true
  },

  /**
   * 删除编组并更新页面数据
   * @param {string} groupId - 编组ID
   * @param {Object} pageContext - 页面实例 (this)
   * @returns {boolean} 是否删除成功
   */
  removeGroup(groupId, pageContext) {
    if (!groupId) {
      logger.error('删除编组失败: 无效的编组ID')
      return false
    }

    // 删除编组从存储
    const result = DataManager.removeGroup(groupId)
    if (!result) return false

    // 更新页面数据
    if (pageContext && pageContext.data && Array.isArray(pageContext.data.groups)) {
      const groups = pageContext.data.groups.filter(g => g.id !== groupId)
      pageContext.setData({ groups })
    }

    return true
  },

  /**
   * 更新编组成员设备
   * @param {string} groupId - 编组ID
   * @param {Array} deviceIds - 设备ID数组
   * @param {Object} pageContext - 页面实例 (this)
   * @returns {boolean} 是否更新成功
   */
  updateGroupDevices(groupId, deviceIds, pageContext) {
    if (!groupId) {
      logger.error('更新编组成员设备失败: 无效的编组ID')
      return false
    }

    if (!Array.isArray(deviceIds)) {
      logger.error('更新编组成员设备失败: deviceIds必须是数组')
      return false
    }

    // 获取编组
    const group = DataManager.getGroupById(groupId)
    if (!group) {
      logger.warn(`更新编组成员设备失败: 编组不存在，ID: ${groupId}`)
      return false
    }

    // 更新编组成员设备
    group.deviceIds = deviceIds
    const result = DataManager.updateGroup(group)
    if (!result) return false

    // 更新页面数据
    if (pageContext && pageContext.data && Array.isArray(pageContext.data.groups)) {
      const groups = [...pageContext.data.groups]
      const index = groups.findIndex(g => g.id === groupId)
      if (index >= 0) {
        // 使用路径更新，减少渲染消耗
        pageContext.setData({
          [`groups[${index}].deviceIds`]: deviceIds,
        })
      }
    }

    return true
  },

  /**
   * 批量更新多个编组
   * @param {Array} groups - 编组对象数组
   * @param {Object} pageContext - 页面实例 (this)
   * @returns {boolean} 是否更新成功
   */
  batchUpdateGroups(groups, pageContext) {
    if (!Array.isArray(groups) || groups.length === 0) {
      logger.error('批量更新编组失败: 无效的编组数组')
      return false
    }

    // 创建批量更新器
    const batchUpdater = pageContext._batchUpdater || createBatchUpdater(pageContext)
    if (!pageContext._batchUpdater) {
      pageContext._batchUpdater = batchUpdater
    }

    // 更新到存储
    let allSuccess = true
    for (const group of groups) {
      if (!group || !group.id) continue
      const result = DataManager.updateGroup(group)
      if (!result) allSuccess = false
    }

    // 更新页面数据
    if (pageContext && pageContext.data && Array.isArray(pageContext.data.groups)) {
      const updatedGroups = [...pageContext.data.groups]
      
      // 更新每个编组
      groups.forEach(group => {
        const index = updatedGroups.findIndex(g => g.id === group.id)
        if (index >= 0) {
          updatedGroups[index] = { ...updatedGroups[index], ...group }
        }
      })
      
      // 使用批量更新
      batchUpdater.update({ groups: updatedGroups })
    }

    return allSuccess
  }
}

module.exports = {
  DeviceOperations,
  GroupOperations
}
